home *** CD-ROM | disk | FTP | other *** search
/ Oh!X 2000 Spring / Oh!X 2000 Spring Special CD-ROM (Japan) (Part 1).7z / Oh!X 2000 Spring Special CD-ROM (Japan) (Part 1).bin / F2JW / trans / search.cpp < prev    next >
C/C++ Source or Header  |  1999-08-28  |  28KB  |  1,169 lines
  1. //
  2. // フランス語翻訳プログラム
  3. // 辞書の検索部
  4. //
  5.  
  6. #include "stdafx.h"
  7. #include    <string.h>
  8. #include    <ctype.h>
  9.  
  10. #include    "f2j.h"
  11. #include    "myprot.h"
  12.  
  13. extern    BOOL        isChanged;
  14. extern    BOOL        isAltChoice;
  15.  
  16. extern    SPECIALWORD    specialWordTable[];
  17. extern    ARTICLE        articleTable[];
  18. extern    PRONOUN        objectNounTable[];
  19. extern    PRONOUN        pronounTable[];
  20. extern    VERB        verbTable1[], verbTable_AN[], verbTable_OZ[];
  21. extern    VERBCHANGE    verbChangeTable[];
  22. extern    PREPOSITION    prepositionTable[];
  23. extern    PROADJECTIVE    proadjectiveTable[];
  24. extern    PROADVERB        proadverbTable[];
  25. extern    COMPARE_WORD    compareTable[];
  26. extern    COMBINE        combineTable[];
  27. extern    QUESTION    questionTable[];
  28. extern    NUMETRIC    numetricTable[];
  29. // extern    CONJUNCTION    conjunctionTable[];
  30. extern    INTERJECTION    interjectionTable[];
  31.  
  32. extern    char        *tokenPtr;
  33. extern    TOKEN    *lastToken;
  34.  
  35. extern    NOUN        *nounTable;
  36. extern    ADJECTIVE    *adjectiveTable;
  37. extern    ADVERB        *adverbTable;
  38.  
  39. //
  40. // Pass2以降に品詞分類がはっきりする単語
  41. // de, en, le, ...など
  42. void
  43. ChangeToSpecial(TOKEN *p, char *s)
  44. {
  45.     int    i;
  46.  
  47.     for(i = 0; specialWordTable[i].french[0]; i++) {
  48.         if(strcmp(specialWordTable[i].french, s) == 0) {
  49.             p->frPart    = specialWordTable[i].frPart;
  50.             p->frAttrib = specialWordTable[i].frAttrib;
  51.             p->jpProp    = JP_PROP_NONE;
  52.             p->what        = &specialWordTable[i];
  53.             return;
  54.         }
  55.     }
  56.     PrintInternalError( "Internall Error <ChangeToSpecial> with <%s>\n", s);
  57. }
  58.  
  59. BOOL
  60. SearchSpecialWord(void)
  61. {
  62.     int    i;
  63.  
  64.     for(i = 0; specialWordTable[i].french[0]; i++) {
  65.         if((specialWordTable[i].elision == TRUE
  66.             && AmatchSE(specialWordTable[i].french))
  67.         || (specialWordTable[i].elision != TRUE
  68.             && AmatchS(specialWordTable[i].french))) {
  69.             if(specialWordTable[i].frShort != FR_SHORT_NONE)
  70.                 PutAbbreviatedWord(specialWordTable[i].frShort);
  71.             PutChoice(specialWordTable[i].frPart,
  72.                 specialWordTable[i].frAttrib,
  73.                 JP_PROP_NONE,
  74.                 &specialWordTable[i], FR_TENSE_NONE);
  75.             return(TRUE);
  76.         }
  77.     }
  78.     return(FALSE);
  79. }
  80.  
  81. //
  82. // 人称代名詞に変更
  83. //
  84. void
  85. ChangeToObjectPronoun(TOKEN *p, char *s)
  86. {
  87.     int    i;
  88.  
  89.     // すでに人称代名詞
  90.     if(IsObjectMatch(p, FR_PART_NOUN_OBJECT_BOTH)) {
  91.         // FR_PART_NOUN_SUBJECTなど他の可能性を消す
  92.         p->frPart = (FR_PART)(p->frPart & (FR_PART)(FR_PART_NOUN_OBJECT_BOTH | FR_PART_NOUN_RECURSIVE));
  93.         return;
  94.     }
  95.  
  96.     for(i = 0; objectNounTable[i].french[0]; i++) {
  97.         if(!strcmp(objectNounTable[i].french, s)) {
  98.             ChangeToPronoun(p, &objectNounTable[i]);
  99.             isChanged  = TRUE;
  100.             return;
  101.         }
  102.     }
  103.     PrintInternalError( "Internall Error <objectNounTable> with <%s>\n", s);
  104. }
  105.  
  106. //
  107. // 代名詞を探す（一般名詞は別）
  108. //
  109. void
  110. ChangeToPronoun(TOKEN *p, char *s)
  111. {
  112.     int    i;
  113.  
  114.     for(i = 0; pronounTable[i].french[0]; i++) {
  115.         if(!strcmp(pronounTable[i].french, s)) {
  116.             ChangeToPronoun(p, &pronounTable[i]);
  117.             isChanged  = TRUE;
  118.             return;
  119.         }
  120.     }
  121.     PrintInternalError( "Internall Error <ChangeToPronoun> with <%s>\n", s);
  122. }
  123.  
  124. void
  125. ChangeToPronoun(TOKEN *p, PRONOUN *dic)
  126. {
  127.     p->frPart    = FR_PART_NONE;
  128.     p->frAttrib    = dic->frAttrib;
  129.     p->jpProp    = JP_PROP_NONE;
  130.     p->jpUnit    = JP_UNIT_NONE;
  131.     p->jpEmphasis = JP_EMPHASIS_NONE;
  132.     p->what    = dic;
  133.     p->which    = NULL;
  134.  
  135.     JP_PRONOUN    *jpPronoun = dic->jpPronoun;
  136.     int            proposed  = dic->proposed;
  137.     while(proposed--) {
  138.         p->frPart    = (FR_PART)  (p->frPart   | jpPronoun->frPart);
  139. //        p->frAttrib    = (FR_ATTRIB)(p->frAttrib | jpPronoun->myFrAttrib);
  140.         p->jpProp    = (JP_PROP)  (p->jpProp   | jpPronoun->myJpProp);
  141.         p->jpUnit    = (JP_UNIT)     (p->jpUnit      | jpPronoun->jpUnit);
  142.         p->jpEmphasis |= jpPronoun->jpEmphasis;
  143.         jpPronoun++;
  144.     }
  145.     if(p->frPart == FR_PART_NOUN_IMPERSONAL)
  146.         p->prtControl = PRT_CONTROL_DISABLE;
  147. }
  148.  
  149. BOOL
  150. SearchPronoun(void)
  151. {
  152.     int    i;
  153.  
  154.     for(i = 0; *(pronounTable[i].french); i++) {
  155.         if(AmatchSE(pronounTable[i].french)) {
  156.             PutChoice(FR_PART_NONE, pronounTable[i].frAttrib,
  157.                         JP_PROP_NONE, NULL,    FR_TENSE_NONE);
  158.             ChangeToPronoun(lastToken, &pronounTable[i]);
  159.             return(TRUE);
  160.         }
  161.     }
  162.     return(FALSE);
  163. }
  164.  
  165. void
  166. ChangeToVerb(TOKEN *p, char *s)
  167. {
  168.     VERB    *verbTable = verbTable1;
  169.  
  170.     for( ;verbTable->original[0]; verbTable++) {
  171.         if(!strcmp(s, verbTable->original)) {
  172.             p->frPart = FR_PART_VERB_GENERAL;
  173.             p->frTense = FR_TENSE_ORIGIN;
  174.             p->frAttrib = FR_ATTRIB_NONE;
  175.             p->what = verbTable;
  176.             p->jpProp = GetMaxJpProp(verbTable);
  177.             isChanged = TRUE;
  178.             return;
  179.         }
  180.     }
  181.     PrintInternalError( "Internal Error <ChangeToVerb> with <%s>\n", s);
  182. }
  183.  
  184. //
  185. // 動詞を探す
  186. //
  187. BOOL
  188. SearchVerb(VERB *verbTable)
  189. {
  190.     char    *savPtr = tokenPtr;
  191.     FR_ATTRIB    frAttrib    = FR_ATTRIB_NONE;
  192.     FR_TENSE    frTense        = FR_TENSE_NONE;
  193.  
  194.     for( ;verbTable->original[0]; verbTable++) {
  195.         if(!Amatch(verbTable->root)) continue;
  196.         int change = verbTable->frVerbKind;
  197.         char    *savPtr2 = tokenPtr;
  198.  
  199.         if(change == 0 && AmatchS("")) {        // voiciとか語尾変化しないもの
  200.             PutChoice(FR_PART_VERB_GENERAL, FR_ATTRIB_NONE,
  201.                 GetMaxJpProp(verbTable), verbTable, FR_TENSE_ORDER);
  202.             return(TRUE);
  203.         }
  204.         if(change > 52) change++;
  205.         if(change > 37) change++;
  206.         if(change > 32) change++;
  207.         if(change > 9) change++;
  208.  
  209.         if(PutAllVerbChoice(change, verbTable))
  210.             return(TRUE);
  211.         tokenPtr = savPtr2;
  212.         // 32a, 32bのように活用の種類が２つあるもの
  213.         if((change == 52+3 || change == 37+2 || change == 32+1 || change == 9)
  214.         && PutAllVerbChoice(change+1, verbTable))
  215.             return(TRUE);
  216.         tokenPtr = savPtr;
  217.     }
  218.     return(FALSE);
  219. }
  220.  
  221. FR_TENSE_ATTRIB    frTenseAttribTable_Imperfect[6] = 
  222. {
  223. // nousの現在形は、半過去といっしょに探す
  224.     { FR_TENSE_PRESENT,        FR_ATTRIB_NOUS },
  225.     { FR_TENSE_IMPERFECT,    (FR_ATTRIB)(FR_ATTRIB_JE | FR_ATTRIB_TU) },
  226.     { FR_TENSE_IMPERFECT,    FR_ATTRIB_IL_ELLE },
  227.     { FR_TENSE_IMPERFECT,    FR_ATTRIB_NOUS },
  228.     { FR_TENSE_IMPERFECT,    FR_ATTRIB_VOUS },
  229.     { FR_TENSE_IMPERFECT,    FR_ATTRIB_ILS}
  230. };
  231.  
  232. char    *frVerbTailTable_Imperfect[6] =
  233. {
  234.     "ons", "ais", "ait", "ions", "iez", "aient"
  235. };
  236.  
  237. FR_ATTRIB    frAttribTable_FutureSimple[6] = 
  238. {    // nousの現在形は、単純過去といっしょに探す
  239.     FR_ATTRIB_JE,
  240.     FR_ATTRIB_TU,
  241.     FR_ATTRIB_IL_ELLE,
  242.     FR_ATTRIB_NOUS,
  243.     FR_ATTRIB_VOUS,
  244.     FR_ATTRIB_ILS,
  245. };
  246.  
  247. char    *frVerbTailTable_FutureSimple[6] =
  248. {
  249.     "ai", "as", "a", "ons", "ez", "ont"
  250. };
  251.  
  252. FR_TENSE_ATTRIB    verbTenseAttribTable[31] = {
  253.     { FR_TENSE_P_PAST,             FR_ATTRIB_NONE },    // 過去分詞 - "e" - "s"
  254.     { FR_TENSE_NONE,            FR_ATTRIB_NONE },    // nousの現在形 - "ons"
  255.     { FR_TENSE_FUTURE_SIMPLE,    FR_ATTRIB_NONE },    // 単純未来形の語幹
  256.     { FR_TENSE_P_PRESENT,        FR_ATTRIB_NONE },
  257.     { FR_TENSE_ORIGIN,            FR_ATTRIB_NONE },
  258.  
  259.     { FR_TENSE_PRESENT,            FR_ATTRIB_JE    },
  260.     { FR_TENSE_PRESENT,            FR_ATTRIB_TU    },
  261.     { FR_TENSE_PRESENT,            FR_ATTRIB_IL_ELLE},
  262. // nousの現在形は、単純過去といっしょに探す
  263.     { FR_TENSE_PRESENT,            FR_ATTRIB_VOUS },
  264.     { FR_TENSE_PRESENT,            FR_ATTRIB_ILS },
  265.  
  266.     { FR_TENSE_PASSE_SIMPLE,    FR_ATTRIB_JE },
  267.     { FR_TENSE_PASSE_SIMPLE,    FR_ATTRIB_TU },
  268.     { FR_TENSE_PASSE_SIMPLE,    FR_ATTRIB_IL_ELLE },
  269.     { FR_TENSE_PASSE_SIMPLE,    FR_ATTRIB_NOUS },
  270.     { FR_TENSE_PASSE_SIMPLE,    FR_ATTRIB_VOUS },
  271.     { FR_TENSE_PASSE_SIMPLE,    FR_ATTRIB_ILS },
  272.  
  273.     { FR_TENSE_SUBJUNCTIVE_PRESENT,    FR_ATTRIB_JE },
  274.     { FR_TENSE_SUBJUNCTIVE_PRESENT,    FR_ATTRIB_TU },
  275.     { FR_TENSE_SUBJUNCTIVE_PRESENT,    FR_ATTRIB_IL_ELLE },
  276.     { FR_TENSE_SUBJUNCTIVE_PRESENT,    FR_ATTRIB_NOUS },
  277.     { FR_TENSE_SUBJUNCTIVE_PRESENT,    FR_ATTRIB_VOUS },
  278.     { FR_TENSE_SUBJUNCTIVE_PRESENT,    FR_ATTRIB_ILS },
  279.  
  280.     { FR_TENSE_SUBJUNCTIVE_IMPERFECT,    FR_ATTRIB_JE },
  281.     { FR_TENSE_SUBJUNCTIVE_IMPERFECT,    FR_ATTRIB_TU },
  282.     { FR_TENSE_SUBJUNCTIVE_IMPERFECT,    FR_ATTRIB_IL_ELLE },
  283.     { FR_TENSE_SUBJUNCTIVE_IMPERFECT,    FR_ATTRIB_NOUS },
  284.     { FR_TENSE_SUBJUNCTIVE_IMPERFECT,    FR_ATTRIB_VOUS },
  285.     { FR_TENSE_SUBJUNCTIVE_IMPERFECT,    FR_ATTRIB_ILS },
  286.  
  287.     { FR_TENSE_ORDER,            FR_ATTRIB_TU },
  288.     { FR_TENSE_ORDER,            FR_ATTRIB_NOUS },
  289.     { FR_TENSE_ORDER,            FR_ATTRIB_VOUS }
  290. };
  291.  
  292.  
  293. //
  294. // 可能性の有る時制、すべての動詞を出力
  295. //
  296. BOOL
  297. PutAllVerbChoice(int kind, VERB *verb)
  298. {
  299.     BOOL    ret = FALSE;
  300.     char    *savPtr = tokenPtr;
  301.     char    *nextPtr = tokenPtr;
  302.     int        i;
  303.  
  304.     FR_ATTRIB    frAttrib = FR_ATTRIB_NONE;
  305.     FR_TENSE    frTense  = FR_TENSE_NONE;
  306.  
  307.     // 過去分詞を先に探す
  308.     if(verbChangeTable[kind][0]
  309.     && Amatch(verbChangeTable[kind][0])) {
  310.         if(Amatch("e"))    frAttrib = (FR_ATTRIB)(frAttrib | FR_ATTRIB_FEMALE);
  311.         if(Amatch("s"))    frAttrib = (FR_ATTRIB)(frAttrib | FR_ATTRIB_PLURAL);
  312.         if(AmatchS(""))    {
  313.             PutChoice(FR_PART_VERB_GENERAL, frAttrib, 
  314.                 GetMaxJpProp(verb),    verb, FR_TENSE_P_PAST);
  315.             nextPtr = tokenPtr;
  316.             isAltChoice = ret = TRUE;
  317.         }
  318.     }
  319.     tokenPtr = savPtr;
  320.  
  321.     // nousの現在形と半過去形を探す
  322.     if(kind == 2 && AmatchS("sommes")) {        // etreだけ例外
  323.         PutChoice(FR_PART_VERB_GENERAL, FR_ATTRIB_NOUS,
  324.                     GetMaxJpProp(verb), verb, FR_TENSE_PRESENT);
  325.         isAltChoice = ret = TRUE;
  326.         return(TRUE);
  327.     }
  328.  
  329.     frAttrib = FR_ATTRIB_NONE;    frTense = FR_TENSE_NONE;
  330.     if(verbChangeTable[kind][1]
  331.     && Amatch(verbChangeTable[kind][1])) {
  332.         char *savPtr2 = tokenPtr;
  333.         for(i = 0; i < 6; i++) {
  334.             tokenPtr = savPtr2;
  335.             if(AmatchS(frVerbTailTable_Imperfect[i])) {
  336.                 PutChoice(FR_PART_VERB_GENERAL,
  337.                         frTenseAttribTable_Imperfect[i].frAttrib,
  338.                         GetMaxJpProp(verb), verb,
  339.                         frTenseAttribTable_Imperfect[i].frTense);
  340.                 nextPtr = tokenPtr;
  341.                 tokenPtr = savPtr;
  342.                 isAltChoice = ret = TRUE;
  343.                 break;
  344.             }
  345.         }
  346.     }
  347.     // 単純未来形/条件法現在形を探す
  348.     tokenPtr = savPtr;
  349.     if(verbChangeTable[kind][2]
  350.     && Amatch(verbChangeTable[kind][2])) {
  351.         for(i = 0; i < 6; i++) {    // 単純未来
  352.             if(AmatchS(frVerbTailTable_FutureSimple[i])) {
  353.                 PutChoice(FR_PART_VERB_GENERAL,
  354.                         frAttribTable_FutureSimple[i],
  355.                         GetMaxJpProp(verb), verb,
  356.                         FR_TENSE_FUTURE_SIMPLE);
  357.                 nextPtr = tokenPtr;
  358.                 tokenPtr = savPtr;
  359.                 isAltChoice = ret = TRUE;
  360.                 break;
  361.             }
  362.         }
  363.         for(i = 1; i < 6; i++) {    // 条件法現在形  i = 0 -> nousの現在形なのでとばす
  364.             if(AmatchS(frVerbTailTable_Imperfect[i])) {
  365.                 PutChoice(FR_PART_VERB_GENERAL,
  366.                         frTenseAttribTable_Imperfect[i].frAttrib,
  367.                         GetMaxJpProp(verb), verb,
  368.                         FR_TENSE_CONDITIONAL_PRESENT);
  369.                 nextPtr = tokenPtr;
  370.                 tokenPtr = savPtr;
  371.                 isAltChoice = ret = TRUE;
  372.                 break;
  373.             }
  374.         }
  375.     }
  376.  
  377.     // 現在分詞を探す
  378.     frAttrib = FR_ATTRIB_NONE;
  379.     tokenPtr = savPtr;
  380.     if(verbChangeTable[kind][3]
  381.     && Amatch(verbChangeTable[kind][3])) {
  382.         if(Amatch("e"))    frAttrib = FR_ATTRIB_FEMALE;
  383.         if(Amatch("s"))    frAttrib = (FR_ATTRIB)(frAttrib | FR_ATTRIB_PLURAL);
  384.         if(AmatchS(""))    {
  385.             nextPtr = tokenPtr;
  386.             PutChoice(FR_PART_VERB_GENERAL, frAttrib, 
  387.                 GetMaxJpProp(verb), verb, FR_TENSE_P_PRESENT);
  388.             isAltChoice = ret = TRUE;
  389.         }
  390.     }
  391.  
  392.     frAttrib = FR_ATTRIB_NONE;    frTense = FR_TENSE_NONE;
  393.     // je chante, il chanteのような場合、全ての組み合わせを探す
  394.     for(i = 4; i < sizeof(VERBCHANGE) / sizeof(char *); i++) {
  395.         tokenPtr = savPtr;
  396.         if(verbChangeTable[kind][i]
  397.         && AmatchS(verbChangeTable[kind][i])) {
  398.             nextPtr = tokenPtr;
  399.             frAttrib = (FR_ATTRIB)(frAttrib | verbTenseAttribTable[i].frAttrib);
  400.             frTense  = (FR_TENSE)(frTense | verbTenseAttribTable[i].frTense);
  401.         }
  402.     }
  403.     if(frTense
  404.     && kind == 3
  405.     && !strncmp(savPtr, "es-", 3)) {
  406.         // aime. -> aime<s>-en, aime<s>-y
  407.         frAttrib = (FR_ATTRIB)(frAttrib | FR_ATTRIB_TU);
  408.         frTense  = (FR_TENSE)(frTense | FR_TENSE_ORDER);
  409.     }
  410.  
  411.     if(frTense) {
  412.         PutChoice(FR_PART_VERB_GENERAL, frAttrib, 
  413.             GetMaxJpProp(verb), verb, frTense);
  414.         isAltChoice = ret = TRUE;
  415.     }
  416.     tokenPtr = nextPtr;
  417.     return(ret);
  418. }
  419.  
  420. void
  421. PrintOutVerbList(void)
  422. {
  423.     VERB    *p;
  424.  
  425.     for(p = verbTable1; p->original[0]; p++) {
  426.         FrnPrintf("%s\n", p->original);
  427.     }
  428.     for(p = verbTable_AN; p->original[0]; p++) {
  429.         FrnPrintf("%s\n", p->original);
  430.     }
  431.     for(p = verbTable_OZ; p->original[0]; p++) {
  432.         FrnPrintf("%s\n", p->original);
  433.     }
  434. }
  435.  
  436. JP_PROP
  437. GetMaxJpProp(VERB *verb)
  438. {
  439.     const JP_VERB    *jpVerb = verb->jpVerb;
  440.     int                proposed = verb->proposed;
  441.     JP_PROP            ret = JP_PROP_NONE;
  442.  
  443.     while(proposed-- > 0) {
  444.         ret |= jpVerb->myJpProp;
  445.         jpVerb++;
  446.     }
  447.     // JP_PROP_NEGATIVE, JP_PROP_PASSIVE等を外す
  448.     ret = ret * JP_PROP_ALL;
  449.     return(ret);
  450. }
  451.  
  452. //
  453. // 冠詞を探す
  454. //
  455. void
  456. ChangeToArticle(TOKEN *p, char *s)
  457. {
  458.     int        i;
  459.  
  460.     for(i = 0; i < articleTable[i].french[0]; i++) {
  461.         if(!strcmp(articleTable[i].french, s)) {
  462.             p->frPart    = articleTable[i].frPart;
  463.             p->frAttrib    = articleTable[i].frAttrib;
  464.             p->jpProp    = JP_PROP_NONE;
  465.             p->what    = &articleTable[i];
  466.             isChanged = TRUE;
  467.             return;
  468.         }
  469.     }
  470.     PrintInternalError( "Internal Error <CahgenToArticle>\n");
  471. }
  472.  
  473. BOOL
  474. SearchArticle(void)
  475. {
  476.     int        i;
  477.  
  478.     for(i = 0; i < articleTable[i].french[0]; i++) {
  479.         if(AmatchSE(articleTable[i].french)) {
  480.             if(articleTable[i].frShort != FR_SHORT_NONE)
  481.                 PutAbbreviatedWord(articleTable[i].frShort);
  482.             PutChoice(articleTable[i].frPart,
  483.                 articleTable[i].frAttrib,
  484.                 JP_PROP_NONE,
  485.                 &articleTable[i], FR_TENSE_NONE);
  486.             return(TRUE);
  487.         }
  488.     }
  489.     return(FALSE);
  490. }
  491.  
  492. //
  493. // 縮略された単語を復活
  494. // 
  495. void
  496. PutAbbreviatedWord(FR_SHORT frShort)
  497. {
  498.     if(frShort == FR_SHORT_A) {
  499.         PutChoice(FR_PART_PREPOSIT_A, FR_ATTRIB_NONE, JP_PROP_NONE, NULL, FR_TENSE_NONE);
  500.         ChangeToPreposition(lastToken, "@");
  501.     }
  502.     if(frShort == FR_SHORT_DE) {
  503. //        PutChoice(FR_PART_PREPOSIT_DE, FR_ATTRIB_NONE, JP_PROP_NONE, NULL, FR_TENSE_NONE);
  504. //        ChangeToPreposition(lastToken, "de");
  505.         PutChoice(FR_PART_SPECIAL_DE, FR_ATTRIB_NONE, JP_PROP_NONE, NULL, FR_TENSE_NONE);
  506.         ChangeToSpecial(lastToken, "de");
  507.     }
  508. }
  509.  
  510. //
  511. // 名詞を探す
  512. //
  513. void
  514. ChangeToNoun(TOKEN *p, char *s)
  515. {
  516.     FR_ATTRIB    frAttrib;
  517.     NOUN    *q = SearchNoun(s, &frAttrib);
  518.  
  519.     if(q) {
  520.         p->frPart    = FR_PART_NOUN_GENERAL;
  521.         p->frAttrib    = frAttrib,
  522.         p->jpProp    = GetNounMaxJpProp(q);
  523.         p->what    = q;
  524.         // とりあえず、一番つぶしが効くものを。
  525.         int    proposed = __max(0, q->proposed-1);
  526.         p->which    = &q->jpNoun[proposed];
  527.         p->jpUnit    = q->jpNoun[proposed].jpUnit;
  528.         return;
  529.     }
  530.     PrintInternalError( "Internal Error <ChangeToNoun>\n");
  531. }
  532.  
  533. NOUN
  534. *SearchNoun(char *s, FR_ATTRIB *frAttrib)
  535. {
  536.     NOUN    *q = nounTable;
  537.     CMP_WORD    cmp;
  538.  
  539.     tokenPtr = s;
  540.     // Binary Search
  541.     while(q) {
  542.         cmp = CompareNoun(q->french, q->frChange);
  543.  
  544.         if(cmp & CMP_WORD_LEFT)    { q = q->left;    continue; }
  545.         if(cmp & CMP_WORD_RIGHT){ q = q->right;    continue; }
  546.  
  547.         *frAttrib = (FR_ATTRIB)(q->frAttrib | FR_ATTRIB_LEVEL3);
  548.  
  549.         if(cmp & CMP_WORD_PLURAL) {
  550.             *frAttrib = (FR_ATTRIB)(*frAttrib & (~FR_ATTRIB_SINGLE));
  551.             *frAttrib = (FR_ATTRIB)(*frAttrib | FR_ATTRIB_PLURAL);
  552.         }
  553.         if(!(*frAttrib & FR_ATTRIB_PLURAL)) {
  554.             // 複数形でないものは､全て単数形
  555.             *frAttrib = (FR_ATTRIB)(*frAttrib | FR_ATTRIB_SINGLE);
  556.         }
  557.         if(cmp & CMP_WORD_FEMALE) {    // 語尾に'e'が付いていた
  558.             *frAttrib = (FR_ATTRIB)(*frAttrib & (~FR_ATTRIB_MALE));
  559.             *frAttrib = (FR_ATTRIB)(*frAttrib | FR_ATTRIB_FEMALE);
  560.         }
  561.         return(q);
  562.     }
  563.     return(NULL);
  564. }
  565.  
  566. BOOL
  567. SearchNoun(void)
  568. {
  569.     FR_ATTRIB    frAttrib;
  570.     NOUN    *q = nounTable;
  571.     CMP_WORD    cmp;
  572.  
  573.     // Binary Search
  574.     while(q) {
  575.         cmp = CompareNoun(q->french, q->frChange);
  576.  
  577.         if(cmp & CMP_WORD_LEFT)    { q = q->left;    continue; }
  578.         if(cmp & CMP_WORD_RIGHT){ q = q->right;    continue; }
  579.  
  580.         frAttrib = (FR_ATTRIB)(q->frAttrib | FR_ATTRIB_LEVEL3);
  581.  
  582.         if(cmp & CMP_WORD_PLURAL) {
  583.             frAttrib = (FR_ATTRIB)(frAttrib & (~FR_ATTRIB_SINGLE));
  584.             frAttrib = (FR_ATTRIB)(frAttrib | FR_ATTRIB_PLURAL);
  585.         }
  586.         if(!(frAttrib & FR_ATTRIB_PLURAL)) {
  587.             // 複数形でないものは､全て単数形
  588.             frAttrib = (FR_ATTRIB)(frAttrib | FR_ATTRIB_SINGLE);
  589.         }
  590.         if(cmp & CMP_WORD_FEMALE) {    // 語尾に'e'が付いていた
  591.             frAttrib = (FR_ATTRIB)(frAttrib & (~FR_ATTRIB_MALE));
  592.             frAttrib = (FR_ATTRIB)(frAttrib | FR_ATTRIB_FEMALE);
  593.         }
  594.  
  595.         PutChoice(FR_PART_NOUN_GENERAL,
  596.             frAttrib,
  597.             GetNounMaxJpProp(q),
  598.             q,
  599.             FR_TENSE_NONE);
  600.         // とりあえず、一番つぶしが効くものを。
  601.         int    proposed = __max(0, q->proposed-1);
  602.         lastToken->which = &q->jpNoun[proposed];
  603.         // 本当は、選んだ方がちゃんと良いでしょうね
  604.         lastToken->jpUnit = q->jpNoun[proposed].jpUnit;
  605.         return(TRUE);
  606.     }
  607.     return(FALSE);
  608. }
  609.  
  610. JP_PROP
  611. GetNounMaxJpProp(NOUN *p)
  612. {
  613.     JP_PROP    jpProp = JP_PROP_NONE;
  614.     int        i, proposed = p->proposed;
  615.  
  616.     for(i = 0; i < proposed; i++) {
  617.         jpProp = (JP_PROP)(jpProp | p->jpNoun[i].jpProp);
  618.     }
  619.     return(jpProp);
  620. }
  621.  
  622. //
  623. // 形容詞を探す
  624. //
  625. void
  626. ChangeToProadjective(TOKEN *p, char *s)
  627. {
  628.     int        i;
  629.  
  630.     for(i = 0; proadjectiveTable[i].french[0]; i++) {
  631.         if(!strcmp(proadjectiveTable[i].french, s)) {
  632.             ChangeToProadjective(p, &proadjectiveTable[i]);
  633.             return;
  634.         }
  635.     }
  636.     PrintInternalError( "Internal Error <ChangeToProadjective> with <%s>\n", s);
  637. }
  638.  
  639. void
  640. ChangeToProadjective(TOKEN *p, PROADJECTIVE *dic)
  641. {
  642.     p->frPart    = GetMaxProadjectiveFrPart(dic);
  643.     p->frAttrib    = dic->frAttrib;
  644.     p->jpProp    = JP_PROP_CONDITION;
  645.     p->what    = dic;
  646.     isChanged = TRUE;
  647. }
  648.  
  649. FR_PART
  650. GetMaxProadjectiveFrPart(PROADJECTIVE *proadjective)
  651. {
  652.     JP_PROADJECTIVE    *jpProadjective = proadjective->jpProadjective;
  653.     int        proposed = proadjective->proposed;
  654.     FR_PART    frPart = FR_PART_NONE;
  655.  
  656.     while(proposed-- > 0) {
  657.         frPart = (FR_PART)(frPart | jpProadjective->frPart);
  658.         jpProadjective++;
  659.     }
  660.     return(frPart);
  661. }
  662.  
  663. BOOL
  664. SearchProadjective(void )
  665. {
  666.     int        i;
  667.  
  668.     for(i = 0; proadjectiveTable[i].french[0]; i++) {
  669.         if(AmatchS(proadjectiveTable[i].french)) {
  670.             PutChoice(GetMaxProadjectiveFrPart(&proadjectiveTable[i]),
  671.                 proadjectiveTable[i].frAttrib,
  672.                 JP_PROP_CONDITION,
  673.                 &proadjectiveTable[i],
  674.                 FR_TENSE_NONE);
  675.             lastToken->frPartChoice = FR_PART_ADJECTIVE;    // 名詞の目的語にはならない
  676.             return(TRUE);
  677.         }
  678.     }
  679.     return(FALSE);
  680. }
  681.  
  682. //
  683. // 形容詞
  684. //
  685. void
  686. ChangeToAdjective(TOKEN *p, char *s)
  687. {
  688.     char    *savToken = tokenPtr;
  689.     tokenPtr = s;
  690.     ADJECTIVE    *q = adjectiveTable;
  691.  
  692.     // 指示(一般)代名詞の検索
  693.     // Binary Search
  694.     while(q) {
  695.         CMP_WORD cmp = CompareNoun(q->french, q->frChange);
  696.  
  697.         if(cmp & CMP_WORD_LEFT)    { q = q->left;    continue; }
  698.         if(cmp & CMP_WORD_RIGHT){ q = q->right;    continue; }
  699.  
  700.         ChangeToAdjective(p, q, cmp);
  701.         break;
  702.     }
  703.     tokenPtr = savToken;
  704. }
  705.  
  706. void
  707. ChangeToAdjective(TOKEN *p, ADJECTIVE *dic, CMP_WORD cmp)
  708. {
  709.     FR_ATTRIB    frAttrib = dic->frAttrib;
  710.  
  711.     if(cmp & CMP_WORD_PLURAL) {
  712.         frAttrib = (FR_ATTRIB)(frAttrib & (~FR_ATTRIB_SINGLE));
  713.         frAttrib = (FR_ATTRIB)(frAttrib | FR_ATTRIB_PLURAL);
  714.     }
  715.     if(cmp & CMP_WORD_FEMALE) {    // 語尾に'e'が付いていた
  716.         frAttrib = (FR_ATTRIB)(frAttrib & (~FR_ATTRIB_MALE));
  717.         frAttrib = (FR_ATTRIB)(frAttrib | FR_ATTRIB_FEMALE);
  718.     }
  719.     p->frPart    = FR_PART_ADJECTIVE_GENERAL;
  720.     p->frAttrib    = frAttrib;
  721.     p->jpProp    = GetAdjectiveMaxJpProp(dic);
  722.     p->what    = dic;
  723.     p->which    = dic->jpAdjective;
  724.  
  725.     isChanged = TRUE;
  726. }
  727.  
  728. BOOL
  729. SearchAdjective(void)
  730. {
  731.     ADJECTIVE    *q = adjectiveTable;
  732.  
  733.     // 指示(一般)代名詞の検索
  734.     // Binary Search
  735.     while(q) {
  736.         CMP_WORD cmp = CompareNoun(q->french, q->frChange);
  737.  
  738.         if(cmp & CMP_WORD_LEFT)    { q = q->left;    continue; }
  739.         if(cmp & CMP_WORD_RIGHT){ q = q->right;    continue; }
  740.  
  741.         PutChoice(FR_PART_ADJECTIVE_GENERAL,
  742.             FR_ATTRIB_NONE,
  743.             JP_PROP_NONE,
  744.             q,
  745.             FR_TENSE_NONE);
  746.  
  747.         ChangeToAdjective(lastToken, q, cmp);
  748.         return(TRUE);
  749.     }
  750.     return(FALSE);
  751. }
  752.  
  753. JP_PROP
  754. GetAdjectiveMaxJpProp(ADJECTIVE *p)
  755. {
  756.     JP_PROP    jpProp = JP_PROP_NONE;
  757.     int        i, proposed = p->proposed;
  758.  
  759.     for(i = 0; i < proposed; i++) {
  760.         jpProp |= p->jpAdjective[i].myJpProp;
  761.     }
  762.     return(jpProp);
  763. }
  764.  
  765. JP_ADVERB    dic_jpAdverb_NE("",         JP_KIND_NONE, JP_PROP_NEGATIVE, JP_PROP_ALL);
  766. ADVERB    dic_adverb_NE = { "ne", JPADVERB_DIC(&dic_jpAdverb_NE)    };
  767. //
  768. // 副詞
  769. //
  770. void
  771. ChangeToAdverb(TOKEN *p, char *s)
  772. {
  773.     if(!strcmp(s, dic_adverb_NE.french)) {
  774.         ChangeToAdverb(p, &dic_adverb_NE);
  775.         p->frPart    = FR_PART_ADVERB;
  776.         return;
  777.     }
  778.  
  779.     ADVERB    *q = adverbTable;
  780.     // Binary Search
  781.     while(q) {
  782.         int    cmp    = strcmp(s, q->french);
  783.  
  784.         if(cmp < 0)    { q = q->left;    continue; }
  785.         if(cmp > 0) { q = q->right;    continue; }
  786.  
  787.         ChangeToAdverb(p, q);
  788.         return;
  789.     }
  790.     PrintInternalError( "Internal Error <ChangeToAdverb>\n");
  791. }
  792.  
  793. void
  794. ChangeToAdverb(TOKEN *p, ADVERB *dic)
  795. {
  796.     p->frPart    = FR_PART_ADVERB_GENERAL;
  797.     p->frAttrib    = FR_ATTRIB_NONE,
  798.     p->jpProp    = dic->jpAdverb[0].myJpProp;
  799.     p->what    = dic;
  800.     p->which    = dic->jpAdverb;
  801.     isChanged = TRUE;
  802. }
  803.  
  804. BOOL
  805. SearchAdverb(void)
  806. {
  807.     if(AmatchSE(dic_adverb_NE.french)) {
  808.         PutChoice(FR_PART_ADVERB,
  809.             FR_ATTRIB_NONE,
  810.             JP_PROP_NEGATIVE,
  811.             &dic_adverb_NE,
  812.             FR_TENSE_NONE);
  813.         lastToken->which = &dic_jpAdverb_NE;
  814.         return(TRUE);
  815.     }
  816.  
  817.     ADVERB    *q = adverbTable;
  818.     // Binary Search
  819.     while(q) {
  820.         CMP_WORD cmp = CompareNoun(q->french, FR_CHANGE_NONE);
  821.  
  822.         if(cmp & CMP_WORD_LEFT)    { q = q->left;    continue; }
  823.         if(cmp & CMP_WORD_RIGHT){ q = q->right;    continue; }
  824.  
  825.         PutChoice(FR_PART_ADVERB_GENERAL,
  826.             FR_ATTRIB_NONE,
  827.             q->jpAdverb[0].myJpProp,
  828.             q,
  829.             FR_TENSE_NONE);
  830.         // 一番無難な訳
  831.         lastToken->which = &q->jpAdverb[q->proposed - 1];
  832.         return(TRUE);
  833.     }
  834.     return(FALSE);
  835. }
  836.  
  837. //
  838. // 特殊な副詞を探す
  839. //
  840. void
  841. ChangeToProadverb(TOKEN *p, char *s)
  842. {
  843.     int        i;
  844.  
  845.     for(i = 0; proadverbTable[i].french[0]; i++) {
  846.         if(!strcmp(proadverbTable[i].french, s)) {
  847.             ChangeToProadverb(p, &proadverbTable[i]);
  848.             return;
  849.         }
  850.     }
  851.     PrintInternalError( "Internal Error <ChangeToProadverb> with <%s>\n", s);
  852. }
  853.  
  854. JP_PROP
  855. GetMaxJpProp(PROADVERB *adv)
  856. {
  857.     JP_PROADVERB    *jpAdv = adv->jpProadverb;
  858.     int                proposed = adv->proposed;
  859.     JP_PROP    ret = JP_PROP_NONE;
  860.  
  861.     while(proposed-- > 0) {
  862.         ret |= jpAdv->myJpProp;
  863.         jpAdv++;
  864.     }
  865.     return(ret);
  866. }
  867.  
  868. void
  869. ChangeToProadverb(TOKEN *p, PROADVERB *adv)
  870. {
  871.     p->frPart    = adv->frPart;
  872.     p->frAttrib    = adv->frAttrib;
  873.     p->jpProp    = GetMaxJpProp(adv);
  874.     p->what    = adv;
  875.     int    proposed = adv->proposed;
  876.     p->which    = &adv->jpProadverb[proposed - 1];
  877.     isChanged = TRUE;
  878. }
  879.  
  880.  
  881. BOOL
  882. SearchProadverb(void )
  883. {
  884.     int        i;
  885.  
  886.     for(i = 0; proadverbTable[i].french[0]; i++) {
  887.         if(AmatchS(proadverbTable[i].french)) {
  888.             PutChoice(proadverbTable[i].frPart,
  889.                 proadverbTable[i].frAttrib,
  890.                 GetMaxJpProp(&proadverbTable[i]),
  891.                 &proadverbTable[i],
  892.                 FR_TENSE_NONE);
  893.             int    proposed = proadverbTable[i].proposed;
  894.             lastToken->which = &proadverbTable[i].jpProadverb[proposed - 1];
  895.             return(TRUE);
  896.         }
  897.     }
  898.     return(FALSE);
  899. }
  900.  
  901. BOOL
  902. SearchCompare(void)
  903. {
  904.     int        i;
  905.  
  906.     for(i = 0; compareTable[i].french[0]; i++) {
  907.         if(AmatchS(compareTable[i].french)) {
  908.             PutChoice(compareTable[i].frPart,
  909.                 compareTable[i].frAttrib,
  910.                 JP_PROP_CONDITION,
  911.                 &compareTable[i],
  912.                 FR_TENSE_NONE);
  913.             if(compareTable[i].frPart & FR_PART_ADJECTIVE)
  914.                 ChangeToAdjective(lastToken, compareTable[i].origin);
  915.             else if(compareTable[i].frPart == FR_PART_ADVERB_GENERAL)
  916.                 ChangeToAdverb(lastToken, compareTable[i].origin);
  917.             else if(compareTable[i].frPart & FR_PART_ADVERB)
  918.                 ChangeToProadverb(lastToken, compareTable[i].origin);
  919.             else PrintInternalError( "Internal Error <SearchCompare>\n");
  920.             lastToken->frPart    = compareTable[i].frPart;
  921.             lastToken->frAttrib = compareTable[i].frAttrib;
  922.             return(TRUE);
  923.         }
  924.     }
  925.     return(FALSE);
  926. }
  927.  
  928. //
  929. // 数字を探す
  930. //
  931. BOOL
  932. SearchNumetric(void)
  933. {
  934.     int        i;
  935.     char    *savPtr = tokenPtr;
  936.     const static char    *dummyStr = "数値";
  937.  
  938.     if(isdigit(*tokenPtr)) {
  939.         int    value = 0;
  940.         while(isdigit(*tokenPtr)) {
  941.             value = value * 10 + *tokenPtr++ - '0';
  942.         }
  943.         PutChoice(FR_PART_NUMETRIC_NUMBER,
  944.             FR_ATTRIB_NONE, JP_PROP_VOLUME, &dummyStr, FR_TENSE_NONE);
  945.         lastToken->value = value;
  946.         return(TRUE);
  947.     }
  948.     for(i = 0; numetricTable[i].value >= 0; i++) {
  949.         if(AmatchS(numetricTable[i].french)) {
  950.             PutChoice(numetricTable[i].frPart,
  951.                 FR_ATTRIB_NONE, JP_PROP_VOLUME, &numetricTable[i], FR_TENSE_NONE);
  952.             lastToken->value = numetricTable[i].value;
  953.             lastToken->jpUnit = JP_UNIT_NONE;
  954.             return(TRUE);
  955.         }
  956.         tokenPtr = savPtr;
  957.     }
  958.     return(FALSE);
  959. }
  960.  
  961. //
  962. // 前置詞を探す
  963. //
  964. void
  965. ChangeToPreposition(TOKEN *p, char *s)
  966. {
  967.     for(int i = 0; prepositionTable[i].french[0]; i++) {
  968.         if(!strcmp(prepositionTable[i].french, s)) {
  969.             ChangeToPreposition(p, &prepositionTable[i]);
  970.             return;
  971.         }
  972.     }
  973.     PrintInternalError( "Internal Error <ChangeToPreposition> with <%s>\n", s);
  974. }
  975.  
  976. void
  977. ChangeToPreposition(TOKEN *p, PREPOSITION *dic)
  978. {
  979.     p->frPart    = dic->frPart;
  980.     p->frAttrib    = FR_ATTRIB_NONE;
  981.     p->jpProp    = JP_PROP_NONE;
  982.     p->what    = dic;
  983.  
  984.     p->frPartParent = GetMaxParentForPreposition(dic);
  985.     p->frPartChoice = (FR_PART)(FR_PART_PREPOSIT | FR_PART_OBJECT);
  986.  
  987.     isChanged = TRUE;
  988. }
  989.  
  990. BOOL
  991. SearchPreposition(void)
  992. {
  993.     int        i;
  994.  
  995.     for(i = 0; prepositionTable[i].french[0]; i++) {
  996.         if(AmatchSE(prepositionTable[i].french)) {
  997.             PutChoice(prepositionTable[i].frPart,
  998.                 FR_ATTRIB_NONE,
  999.                 JP_PROP_NONE,
  1000.                 &prepositionTable[i],
  1001.                 FR_TENSE_NONE);
  1002.             ChangeToPreposition(lastToken, &prepositionTable[i]);
  1003.             return(TRUE);
  1004.         }
  1005.     }
  1006.     return(NULL);
  1007. }
  1008.  
  1009. FR_PART
  1010. GetMaxParentForPreposition(PREPOSITION *prep)
  1011. {
  1012.     FR_PART    frPart = FR_PART_NONE;
  1013.  
  1014.     JP_PREPOSITION *jpPrep = prep->jpPreposition;
  1015.     int    proposed = prep->proposed;
  1016.  
  1017.     while(proposed-- > 0) {
  1018.         if(jpPrep->parent.frPart != FR_PART_ALL)
  1019.             frPart = (FR_PART)(frPart | jpPrep->parent.frPart);
  1020.         jpPrep++;
  1021.     }
  1022.     return(frPart);
  1023. }
  1024.  
  1025. void
  1026. PrintOutPrepositionList(void)
  1027. {
  1028.     int        i;
  1029.  
  1030.     for(i = 0; prepositionTable[i].french[0]; i++) {
  1031.         FrnPrintf("%s\n", prepositionTable[i].french);
  1032.     }
  1033. }
  1034.  
  1035. //
  1036. // 接続詞
  1037. //
  1038. void
  1039. ChangeToCombine(TOKEN *p, char *s)
  1040. {
  1041.     int        i;
  1042.  
  1043.     for(i = 0; combineTable[i].french[0]; i++) {
  1044.         if(!strcmp(combineTable[i].french, s)) {
  1045.             ChangeToCombine(p, &combineTable[i]);
  1046.             return;
  1047.         }
  1048.     }
  1049.     PrintInternalError( "Internal Error <ChangeToCombine> with <%s>\n", s);
  1050. }
  1051.  
  1052. void
  1053. ChangeToCombine(TOKEN *p, COMBINE *dic)
  1054. {
  1055.     p->frPart    = dic->frPart;
  1056.     p->frAttrib = FR_ATTRIB_NONE;
  1057.     p->jpProp    = JP_PROP_NONE;
  1058.     p->what    = dic;
  1059.     p->frTense    = FR_TENSE_NONE;
  1060.     isChanged = TRUE;
  1061. }
  1062.  
  1063. BOOL
  1064. SearchCombine(void)
  1065. {
  1066.     int        i;
  1067.  
  1068.     for(i = 0; combineTable[i].french[0]; i++) {
  1069.         if((combineTable[i].isSymbol && AmatchSymbol(combineTable[i].french))
  1070.         ||(!combineTable[i].isSymbol && AmatchS(combineTable[i].french))) {
  1071.             PutChoice(combineTable[i].frPart,
  1072.                 FR_ATTRIB_NONE,
  1073.                 JP_PROP_NONE,
  1074.                 &combineTable[i],
  1075.                 FR_TENSE_NONE);
  1076.             ChangeToCombine(lastToken, &combineTable[i]);
  1077.             return(TRUE);
  1078.         }
  1079.     }
  1080.     return(FALSE);
  1081. }
  1082.  
  1083. //
  1084. // 疑問代名詞（副詞）
  1085. //
  1086. void
  1087. ChangeToQuestion(TOKEN *p, char *s)
  1088. {
  1089.     int        i;
  1090.  
  1091.     for(i = 0; questionTable[i].french[0]; i++) {
  1092.         if(!strcmp(questionTable[i].french, s)) {
  1093.             ChangeToQuestion(p, &questionTable[i]);
  1094.             return;
  1095.         }
  1096.     }
  1097.     PrintInternalError( "Internal Error <ChangeToQuestion>\n");
  1098. }
  1099.  
  1100. void
  1101. ChangeToQuestion(TOKEN *p, QUESTION *dic)
  1102. {
  1103.     p->frPart    = FR_PART_INTERROGATIVE_UNCLEAR;
  1104.     p->frAttrib    = dic->frAttrib;
  1105.     p->jpProp    = JP_PROP_NONE;
  1106.     p->what    = dic;
  1107.     p->which = NULL;
  1108.     p->frPartChoice = dic->frPartChoice;
  1109.     p->jpUnit    = JP_UNIT_NONE;
  1110.     isChanged = TRUE;
  1111. }
  1112.  
  1113. BOOL
  1114. SearchQuestion(void)
  1115. {
  1116.     int        i;
  1117.  
  1118.     for(i = 0; questionTable[i].french[0]; i++) {
  1119.         if(AmatchS(questionTable[i].french)) {
  1120.             PutChoice(FR_PART_INTERROGATIVE_UNCLEAR,
  1121.                 questionTable[i].frAttrib,
  1122.                 JP_PROP_NONE,
  1123.                 &questionTable[i],
  1124.                 FR_TENSE_NONE);
  1125.             ChangeToQuestion(lastToken, &questionTable[i]);
  1126.             return(TRUE);
  1127.         }
  1128.     }
  1129.     return(FALSE);
  1130. }
  1131.  
  1132.  
  1133. BOOL
  1134. SearchInterjection(void)
  1135. {
  1136.     int        i;
  1137.  
  1138.     for(i = 0; interjectionTable[i].french[0]; i++) {
  1139.         if(AmatchS(interjectionTable[i].french)) {
  1140.             PutChoice(interjectionTable[i].frPart,
  1141.                 FR_ATTRIB_NONE,
  1142.                 JP_PROP_NONE,
  1143.                 &interjectionTable[i],
  1144.                 FR_TENSE_NONE);
  1145.             return(TRUE);
  1146.         }
  1147.     }
  1148.     return(FALSE);
  1149. }
  1150.  
  1151.  
  1152. void
  1153. ChangeToInterjection(TOKEN *p, char *s)
  1154. {
  1155.     int        i;
  1156.  
  1157.     for(i = 0; interjectionTable[i].french[0]; i++) {
  1158.         if(!strcmp(interjectionTable[i].french, s)) {
  1159.             p->frPart    = interjectionTable[i].frPart;
  1160.             p->frAttrib    = FR_ATTRIB_NONE;
  1161.             p->jpProp    = JP_PROP_NONE;
  1162.             p->what    = &interjectionTable[i];
  1163.             isChanged = TRUE;
  1164.             return;
  1165.         }
  1166.     }
  1167.     PrintInternalError( "Internal Error <ChangeToInterjection>\n");
  1168. }
  1169.